home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / diffs / gdb-4.12 / bfd / coff-go3.c next >
Encoding:
Text File  |  1994-08-05  |  13.6 KB  |  348 lines
  1. *** orig/gdb-4.12/bfd/coff-go3.c    Mon Jul 25 23:07:12 1994
  2. --- src/gdb-4.12/bfd/coff-go3.c    Mon Jul 25 23:07:44 1994
  3. ***************
  4. *** 0 ****
  5. --- 1,342 ----
  6. + /* BFD back-end for Intel 386 COFF files under go32.
  7. +    Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
  8. +    Written by Cygnus Support.
  9. + 
  10. + This file is part of BFD, the Binary File Descriptor library.
  11. + 
  12. + This program is free software; you can redistribute it and/or modify
  13. + it under the terms of the GNU General Public License as published by
  14. + the Free Software Foundation; either version 2 of the License, or
  15. + (at your option) any later version.
  16. + 
  17. + This program is distributed in the hope that it will be useful,
  18. + but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20. + GNU General Public License for more details.
  21. + 
  22. + You should have received a copy of the GNU General Public License
  23. + along with this program; if not, write to the Free Software
  24. + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  25. + 
  26. + #include "bfd.h"
  27. + #include "sysdep.h"
  28. + #include "libbfd.h"
  29. + #include "obstack.h"
  30. + #include "coff/i386.h"
  31. + #include "coff/internal.h"
  32. + #include "libcoff.h"
  33. + 
  34. + static bfd_reloc_status_type coff_i386_reloc PARAMS ((bfd *abfd,
  35. +                               arelent *reloc_entry,
  36. +                               asymbol *symbol,
  37. +                               PTR data,
  38. +                               asection *input_section,
  39. +                               bfd *output_bfd,
  40. +                               char **error_message));
  41. + 
  42. + /* For some reason when using i386 COFF the value stored in the .text
  43. +    section for a reference to a common symbol is the value itself plus
  44. +    any desired offset.  Ian Taylor, Cygnus Support.  */
  45. + 
  46. + /* If we are producing relocateable output, we need to do some
  47. +    adjustments to the object file that are not done by the
  48. +    bfd_perform_relocation function.  This function is called by every
  49. +    reloc type to make any required adjustments.  */
  50. + 
  51. + static bfd_reloc_status_type
  52. + coff_i386_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
  53. +          error_message)
  54. +      bfd *abfd;
  55. +      arelent *reloc_entry;
  56. +      asymbol *symbol;
  57. +      PTR data;
  58. +      asection *input_section;
  59. +      bfd *output_bfd;
  60. +      char **error_message;
  61. + {
  62. +   symvalue diff;
  63. + 
  64. +   if (output_bfd == (bfd *) NULL)
  65. +     return bfd_reloc_continue;
  66. + 
  67. +   if (bfd_is_com_section (symbol->section))
  68. +     {
  69. +       /* We are relocating a common symbol.  The current value in the
  70. +      object file is ORIG + OFFSET, where ORIG is the value of the
  71. +      common symbol as seen by the object file when it was compiled
  72. +      (this may be zero if the symbol was undefined) and OFFSET is
  73. +      the offset into the common symbol (normally zero, but may be
  74. +      non-zero when referring to a field in a common structure).
  75. +      ORIG is the negative of reloc_entry->addend, which is set by
  76. +      the CALC_ADDEND macro below.  We want to replace the value in
  77. +      the object file with NEW + OFFSET, where NEW is the value of
  78. +      the common symbol which we are going to put in the final
  79. +      object file.  NEW is symbol->value.  */
  80. +       diff = symbol->value + reloc_entry->addend;
  81. +     }
  82. +   else
  83. +     {
  84. +       /* For some reason bfd_perform_relocation always effectively
  85. +      ignores the addend for a COFF target when producing
  86. +      relocateable output.  This seems to be always wrong for 386
  87. +      COFF, so we handle the addend here instead.  */
  88. +       diff = reloc_entry->addend;
  89. +     }
  90. + 
  91. + #define DOIT(x) \
  92. +   x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
  93. + 
  94. +   if (diff != 0)
  95. +     {
  96. +       const reloc_howto_type *howto = reloc_entry->howto;
  97. +       unsigned char *addr = (unsigned char *) data + reloc_entry->address;
  98. + 
  99. +       switch (howto->size)
  100. +     {
  101. +     case 0:
  102. +       {
  103. +         char x = bfd_get_8 (abfd, addr);
  104. +         DOIT (x);
  105. +         bfd_put_8 (abfd, x, addr);
  106. +       }
  107. +       break;
  108. + 
  109. +     case 1:
  110. +       {
  111. +         short x = bfd_get_16 (abfd, addr);
  112. +         DOIT (x);
  113. +         bfd_put_16 (abfd, x, addr);
  114. +       }
  115. +       break;
  116. + 
  117. +     case 2:
  118. +       {
  119. +         long x = bfd_get_32 (abfd, addr);
  120. +         DOIT (x);
  121. +         bfd_put_32 (abfd, x, addr);
  122. +       }
  123. +       break;
  124. + 
  125. +     default:
  126. +       abort ();
  127. +     }
  128. +     }
  129. + 
  130. +   /* Now let bfd_perform_relocation finish everything up.  */
  131. +   return bfd_reloc_continue;
  132. + }
  133. + 
  134. + static reloc_howto_type howto_table[] = 
  135. + {
  136. +   {0},
  137. +   {1},
  138. +   {2},
  139. +   {3},
  140. +   {4},
  141. +   {5},
  142. +   HOWTO (R_DIR32,               /* type */                                 
  143. +      0,                    /* rightshift */                           
  144. +      2,                    /* size (0 = byte, 1 = short, 2 = long) */ 
  145. +      32,                    /* bitsize */                   
  146. +      false,                    /* pc_relative */                          
  147. +      0,                    /* bitpos */                               
  148. +      complain_overflow_bitfield, /* complain_on_overflow */
  149. +      coff_i386_reloc,       /* special_function */                     
  150. +      "dir32",               /* name */                                 
  151. +      true,                    /* partial_inplace */                      
  152. +      0xffffffff,            /* src_mask */                             
  153. +      0xffffffff,            /* dst_mask */                             
  154. +      false),                /* pcrel_offset */
  155. +   {7},
  156. +   {010},
  157. +   {011},
  158. +   {012},
  159. +   {013},
  160. +   {014},
  161. +   {015},
  162. +   {016},
  163. +   HOWTO (R_RELBYTE,        /* type */                                 
  164. +      0,            /* rightshift */                           
  165. +      0,            /* size (0 = byte, 1 = short, 2 = long) */ 
  166. +      8,            /* bitsize */                   
  167. +      false,            /* pc_relative */                          
  168. +      0,            /* bitpos */                               
  169. +      complain_overflow_bitfield, /* complain_on_overflow */
  170. +      coff_i386_reloc,    /* special_function */                     
  171. +      "8",            /* name */                                 
  172. +      true,            /* partial_inplace */                      
  173. +      0x000000ff,        /* src_mask */                             
  174. +      0x000000ff,        /* dst_mask */                             
  175. +      false),        /* pcrel_offset */
  176. +   HOWTO (R_RELWORD,        /* type */                                 
  177. +      0,            /* rightshift */                           
  178. +      1,            /* size (0 = byte, 1 = short, 2 = long) */ 
  179. +      16,            /* bitsize */                   
  180. +      false,            /* pc_relative */                          
  181. +      0,            /* bitpos */                               
  182. +      complain_overflow_bitfield, /* complain_on_overflow */
  183. +      coff_i386_reloc,    /* special_function */                     
  184. +      "16",            /* name */                                 
  185. +      true,            /* partial_inplace */                      
  186. +      0x0000ffff,        /* src_mask */                             
  187. +      0x0000ffff,        /* dst_mask */                             
  188. +      false),        /* pcrel_offset */
  189. +   HOWTO (R_RELLONG,        /* type */                                 
  190. +      0,            /* rightshift */                           
  191. +      2,            /* size (0 = byte, 1 = short, 2 = long) */ 
  192. +      32,            /* bitsize */                   
  193. +      false,            /* pc_relative */                          
  194. +      0,            /* bitpos */                               
  195. +      complain_overflow_bitfield, /* complain_on_overflow */
  196. +      coff_i386_reloc,    /* special_function */                     
  197. +      "32",            /* name */                                 
  198. +      true,            /* partial_inplace */                      
  199. +      0xffffffff,        /* src_mask */                             
  200. +      0xffffffff,        /* dst_mask */                             
  201. +      false),        /* pcrel_offset */
  202. +   HOWTO (R_PCRBYTE,        /* type */                                 
  203. +      0,            /* rightshift */                           
  204. +      0,            /* size (0 = byte, 1 = short, 2 = long) */ 
  205. +      8,            /* bitsize */                   
  206. +      true,            /* pc_relative */                          
  207. +      0,            /* bitpos */                               
  208. +      complain_overflow_signed, /* complain_on_overflow */
  209. +      coff_i386_reloc,    /* special_function */                     
  210. +      "DISP8",        /* name */                                 
  211. +      true,            /* partial_inplace */                      
  212. +      0x000000ff,        /* src_mask */                             
  213. +      0x000000ff,        /* dst_mask */                             
  214. +      false),        /* pcrel_offset */
  215. +   HOWTO (R_PCRWORD,        /* type */                                 
  216. +      0,            /* rightshift */                           
  217. +      1,            /* size (0 = byte, 1 = short, 2 = long) */ 
  218. +      16,            /* bitsize */                   
  219. +      true,            /* pc_relative */                          
  220. +      0,            /* bitpos */                               
  221. +      complain_overflow_signed, /* complain_on_overflow */
  222. +      coff_i386_reloc,    /* special_function */                     
  223. +      "DISP16",        /* name */                                 
  224. +      true,            /* partial_inplace */                      
  225. +      0x0000ffff,        /* src_mask */                             
  226. +      0x0000ffff,        /* dst_mask */                             
  227. +      false),        /* pcrel_offset */
  228. +   HOWTO (R_PCRLONG,        /* type */                                 
  229. +      0,            /* rightshift */                           
  230. +      2,            /* size (0 = byte, 1 = short, 2 = long) */ 
  231. +      32,            /* bitsize */                   
  232. +      true,            /* pc_relative */                          
  233. +      0,            /* bitpos */                               
  234. +      complain_overflow_signed, /* complain_on_overflow */
  235. +      coff_i386_reloc,    /* special_function */                     
  236. +      "DISP32",        /* name */                                 
  237. +      true,            /* partial_inplace */                      
  238. +      0xffffffff,        /* src_mask */                             
  239. +      0xffffffff,        /* dst_mask */                             
  240. +      false)            /* pcrel_offset */
  241. + };
  242. + 
  243. + /* Turn a howto into a reloc  nunmber */
  244. + 
  245. + #define SELECT_RELOC(x,howto) { x = howto->type; }
  246. + #define BADMAG(x) I386BADMAG(x)
  247. + #define I386 1            /* Customize coffcode.h */
  248. + 
  249. + #define RTYPE2HOWTO(cache_ptr, dst) \
  250. +         cache_ptr->howto = howto_table + (dst)->r_type;
  251. + 
  252. + /* On SCO Unix 3.2.2 the native assembler generates two .data
  253. +    sections.  We handle that by renaming the second one to .data2.  It
  254. +    does no harm to do this for any 386 COFF target.  */
  255. + #define TWO_DATA_SECS
  256. + 
  257. + /* For 386 COFF a STYP_NOLOAD | STYP_BSS section is part of a shared
  258. +    library.  On some other COFF targets STYP_BSS is normally
  259. +    STYP_NOLOAD.  */
  260. + #define BSS_NOLOAD_IS_SHARED_LIBRARY
  261. + 
  262. + /* Compute the addend of a reloc.  If the reloc is to a common symbol,
  263. +    the object file contains the value of the common symbol.  By the
  264. +    time this is called, the linker may be using a different symbol
  265. +    from a different object file with a different value.  Therefore, we
  266. +    hack wildly to locate the original symbol from this file so that we
  267. +    can make the correct adjustment.  This macro sets coffsym to the
  268. +    symbol from the original file, and uses it to set the addend value
  269. +    correctly.  If this is not a common symbol, the usual addend
  270. +    calculation is done, except that an additional tweak is needed for
  271. +    PC relative relocs.
  272. +    FIXME: This macro refers to symbols and asect; these are from the
  273. +    calling function, not the macro arguments.  */
  274. + 
  275. + #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr)        \
  276. +   {                                \
  277. +     coff_symbol_type *coffsym = (coff_symbol_type *) NULL;    \
  278. +     if (ptr && bfd_asymbol_bfd (ptr) != abfd)            \
  279. +       coffsym = (obj_symbols (abfd)                \
  280. +              + (cache_ptr->sym_ptr_ptr - symbols));        \
  281. +     else if (ptr)                        \
  282. +       coffsym = coff_symbol_from (abfd, ptr);            \
  283. +     if (coffsym != (coff_symbol_type *) NULL            \
  284. +     && coffsym->native->u.syment.n_scnum == 0)        \
  285. +       cache_ptr->addend = - coffsym->native->u.syment.n_value;    \
  286. +     else if (ptr && bfd_asymbol_bfd (ptr) == abfd        \
  287. +          && ptr->section != (asection *) NULL)        \
  288. +       cache_ptr->addend = - (ptr->section->vma + ptr->value);    \
  289. +     else                            \
  290. +       cache_ptr->addend = 0;                    \
  291. +     if (ptr && howto_table[reloc.r_type].pc_relative)        \
  292. +       cache_ptr->addend += asect->vma;                \
  293. +   }
  294. + 
  295. + #include "coffcode.h"
  296. + 
  297. + static bfd_target *
  298. + i3coff_object_p(a)
  299. +      bfd *a;
  300. + {
  301. +   return coff_object_p(a);
  302. + }
  303. + 
  304. + bfd_target
  305. + #ifdef TARGET_SYM
  306. +   TARGET_SYM =
  307. + #else
  308. +   i386go32_vec =
  309. + #endif
  310. + {
  311. + #ifdef TARGET_NAME
  312. +   TARGET_NAME,
  313. + #else
  314. +   "coff-go32",            /* name */
  315. + #endif
  316. +   bfd_target_coff_flavour,
  317. +   false,            /* data byte order is little */
  318. +   false,            /* header byte order is little */
  319. + 
  320. +   (HAS_RELOC | EXEC_P |        /* object flags */
  321. +    HAS_LINENO | HAS_DEBUG |
  322. +    HAS_SYMS | HAS_LOCALS | WP_TEXT),
  323. + 
  324. +   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
  325. +   '_',                /* leading underscore */
  326. +   '/',                /* ar_pad_char */
  327. +   15,                /* ar_max_namelen */
  328. + 
  329. +   2,                /* minimum alignment power */
  330. +   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  331. +      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
  332. +      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
  333. +   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  334. +      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
  335. +      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
  336. + 
  337. + /* Note that we allow an object file to be treated as a core file as well. */
  338. +     {_bfd_dummy_target, i3coff_object_p, /* bfd_check_format */
  339. +        bfd_generic_archive_p, i3coff_object_p},
  340. +     {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
  341. +        bfd_false},
  342. +     {bfd_false, coff_write_object_contents, /* bfd_write_contents */
  343. +        _bfd_write_archive_contents, bfd_false},
  344. + 
  345. +   JUMP_TABLE(coff),
  346. +   COFF_SWAP_TABLE,
  347. + };
  348.